#pragma once

#include "strategy/strategy_base.h"
#include "utils/ring_buffer.h"
#include <numeric>

// 使用RingBuffer优化的移动平均策略
class OptimizedMaStrategy : public StrategyBase {
public:
    OptimizedMaStrategy(int short_period = 5, int long_period = 20)
        : StrategyBase("OptimizedMA")
        , short_period_(short_period)
        , long_period_(long_period)
        , short_ma_prices_(short_period)  // 使用RingBuffer，大小固定为短期MA周期
        , long_ma_prices_(long_period)    // 使用RingBuffer，大小固定为长期MA周期
        , position_(0)
        , short_ma_sum_(0.0)
        , long_ma_sum_(0.0) {}

    void initialize() override {
        short_ma_prices_.clear();
        long_ma_prices_.clear();
        position_ = 0;
        short_ma_sum_ = 0.0;
        long_ma_sum_ = 0.0;
    }

    void on_market_data(const MarketData& data) override {
        // 更新短期MA
        if (short_ma_prices_.full()) {
            short_ma_sum_ -= short_ma_prices_.front();
        }
        short_ma_prices_.push_back(data.close);
        short_ma_sum_ += data.close;

        // 更新长期MA
        if (long_ma_prices_.full()) {
            long_ma_sum_ -= long_ma_prices_.front();
        }
        long_ma_prices_.push_back(data.close);
        long_ma_sum_ += data.close;

        // 当收集到足够的数据时开始生成信号
        if (short_ma_prices_.full() && long_ma_prices_.full()) {
            // 使用预计算的和来计算移动平均值，避免每次都重新计算
            double short_ma = short_ma_sum_ / short_period_;
            double long_ma = long_ma_sum_ / long_period_;

            Signal signal;
            signal.symbol = data.symbol;
            signal.timestamp = data.timestamp;
            signal.price = data.close;

            // 金叉：短期MA上穿长期MA
            if (short_ma > long_ma && position_ <= 0) {
                signal.type = SignalType::BUY;
                signal.quantity = 1.0;  // 简单起见，固定交易量
                position_ = 1;
                emit_signal(signal);
            }
            // 死叉：短期MA下穿长期MA
            else if (short_ma < long_ma && position_ >= 0) {
                signal.type = SignalType::SELL;
                signal.quantity = 1.0;
                position_ = -1;
                emit_signal(signal);
            }
        }
    }

    void finalize() override {
        // 回测结束时平掉所有仓位
        if (position_ != 0 && !short_ma_prices_.empty()) {
            Signal signal;
            signal.symbol = ""; // 使用最后一个交易的symbol
            signal.timestamp = ""; // 使用最后的时间戳
            signal.price = short_ma_prices_.back();
            signal.type = position_ > 0 ? SignalType::SELL : SignalType::BUY;
            signal.quantity = std::abs(position_);
            
            emit_signal(signal);
        }
    }

private:
    int short_period_;
    int long_period_;
    utils::RingBuffer<double> short_ma_prices_;  // 使用RingBuffer替代std::deque
    utils::RingBuffer<double> long_ma_prices_;
    int position_;  // 1: 多头, -1: 空头, 0: 空仓
    
    // 预计算的移动平均值之和，避免每次都重新计算
    double short_ma_sum_;
    double long_ma_sum_;
};